#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include <ctype.h>
#include <sys/time.h>
#include "rede.h"
#include "alggen.h"

//
Node * alocaNode(Solucao solution){
	Node * novo;
	novo=(Node*)malloc(sizeof(Node));
	if(novo==NULL){
		erro();
		exit(1);
	}
	
	novo->sol=solution;
	novo->prox=novo->ant=NULL;
	
	return novo;
	
}
//
/*
void liberaSolutionList(SolutionList * lista){
	printf("TESTE 1\n");
	Node * aux;
	
	aux=lista->ini;
	
	while(aux!=NULL){
		Node * libera;
		libera=aux;
		if(aux->prox==NULL) break;
		aux=aux->prox;
		aux->ant=NULL;
		printf("TESTE 2 %d\n", lista->tam);
		liberaRnet(libera->sol.rnet);
		liberaMatriz(libera->sol.rotas, TAMANHO_n);
		
		
		
		free(libera);
		
		lista->tam--;
	}
	Node * libera;
	libera = lista->fim;
	printf("TESTE 4\n");
	liberaRnet(libera->sol.rnet);
	liberaMatriz(libera->sol.rotas,TAMANHO_n);
	
	free(lista->ini);
	free(lista->fim);
	free(lista);
}
*/

Solucao atribuiDemandaLista( Lista *list, int ** qtdRotas, Solucao sol)
{
	RNET ** rnet;
	Rede ** rede;
	float taxaFitness;
	int i,j;
	No * aux;
	int rota,l,k, cont,freq;
	int saltos,erros;
	int contaRotaZero;
	int listaTaxada;
	
	rnet=alocaMatrizRNET();
	//aloca o vetorSlotsZERADOS
	alocaVetorSlots(rnet);
	rede=alocaRede();
	erros=0;
	contaRotaZero=0;
	taxaFitness=TAXA_FITNESS;
	listaTaxada=list->tam*taxaFitness;
	
	
	for(aux=list->ini; aux!=NULL; aux=aux->prox){
			freq=9999;
			//if(i!=j && rede[i][j].demanda >0)//quer dizer que eh uma ligacao direta dos nodos
			{	
				printf("\t\t\tDEMANDA DE %d para %d-------------------\n", aux->s,aux->d);
				//rota=calculaRota(rnet,aux->s, aux->d, &freq);
				rota=calculaRotaRandom(rnet, qtdRotas,aux->s, aux->d, &freq, &contaRotaZero, listaTaxada);
				if(rota==9999){
					printf("Nao achou rota nenhuma!\n");
					erros++;
					continue;
				}
				saltos=contaSaltos(aux->s,aux->d,rota); //o numero de saltos existentes naquela demanda 
				printf("Frequencia utilizada: %d // Rota: %d\n", freq, rota);
				
				if(rota!=9999) //quer dizer que existe uma rota que pode ser alocada
				{
					//printf("Rota: %d\n", rota);
					rede[aux->s][aux->d].w=freq;
					rede[aux->s][aux->d].rota=rota;
					rede[aux->s][aux->d].demanda=traf[aux->s][aux->d];
					for(k=0; k<saltos; k++) 
					{	
						cont=0;
						if(M[aux->s][aux->d][rota][k+1]==-1 || freq==9999) break;
						if(E[M[aux->s][aux->d][rota][k]][M[aux->s][aux->d][rota][k+1]] == 0){
							printf("\n\n\tO mostra rota achou uma não existente em %d %d\n\n", aux->s, aux->d);
							break;
						}
						//printf("NODO SAIDA %d\tNODO DESTINO %d\n", M[aux->s][aux->d][rota][k], M[aux->s][aux->d][rota][k+1]);
						//printf("freq: %d\n", rede[aux->s][aux->d].w);
						//printf("Rota: %d\n", rede[i][j].rota);
						//printf("DEMANDA: %d\n", rede[aux->s][aux->d].demanda);
						
						for(l=freq; l< (freq+traf[aux->s][aux->d]); l++)
						{
							if(cont==traf[aux->s][aux->d]) break;
							//atribui 1 nos slots
							rnet[M[aux->s][aux->d][rota][k]][M[aux->s][aux->d][rota][k+1]].slots[l]=1;
							cont++;
							
						}
						if(rnet[M[aux->s][aux->d][rota][k]][M[aux->s][aux->d][rota][k+1]].slots[freq-1]==0)
						{
							//atribui banda de guarda no inicio
							rnet[M[aux->s][aux->d][rota][k]][M[aux->s][aux->d][rota][k+1]].slots[freq-1]=-1;
						}
						if(l<NUM_SLOTS)
						{
							//atribui banda de guarda no final
							rnet[M[aux->s][aux->d][rota][k]][M[aux->s][aux->d][rota][k+1]].slots[l]=-1;
						}
						
					}
					
				}
			}	
		}
		sol.erros=erros;
		sol.confRede=rede;
		sol.rnet=rnet;
		
		return sol;
	}
	
		
void imprimeSolucao( Solucao * sol, int valSol) 
{

	FILE * teste;
	int i,j,k,t;
	teste=fopen("TesteFinalN6_ZM02.txt", "w");
	if(teste == NULL) exit(1);
	for(t=0; t<valSol; t++)
	{
		fprintf(teste,"\n\n\t\tSOLUCAO %d\n\n",t);
		for(i=0; i<n; i++)
		{
			for(j=0; j<n; j++)
			{
				if(E[i][j]==1)
				{
					fprintf(teste,"\t\tLINK DIRETO DE I[%d] J[%d]\n", i, j);

					for(k=0; k<NUM_SLOTS; k++)
					{
						fprintf(teste,"%d ", sol[t].rnet[i][j].slots[k]);
					}
					fprintf(teste,"\n");
					
				}
			}
		}
		fprintf(teste,"ERROS: %d\n", sol[t].erros);
		
		for(i=0; i<n; i++)
		{
			for(j=0; j<n; j++)
			{
				fprintf(teste,"%d ", sol[t].confRede[i][j].rota);
			}	
			fprintf(teste,"\n");	
		}
	}
		fprintf(teste,"\n");
		fprintf(teste,"\n");
}


Solucao alocaSolucaoUnica(){
	//onde num eh o numero de solucoes desejadas
	
	int i,j,k;
	Solucao solution;
	
	//solution=(Solucao*)malloc(sizeof(Solucao)); 
	solution.rnet=alocaMatrizRNET();
	solution.confRede=alocaRede();
	

	return solution;
}
Solucao * alocaSolucao(int num){
	//onde num eh o numero de solucoes desejadas
	
	int i,j,k;
	Solucao * solution;
	
	solution=(Solucao*)malloc(num*sizeof(Solucao)); 
	
	for(i=0; i<num; i++){
		solution[i].rnet=alocaMatrizRNET();
		solution[i].confRede=alocaRede();
		
	}

	return solution;
}

int calculaFitness (Solucao  sol){
	int  j, k,soma;
		soma=0;
		for(j=0; j<n; j++){
			for(k=0 ; k<n; k++){
				if(traf[j][k] >0 && j!=k){
					soma+=calculaPesoFitness(j,k,traf[j][k],sol.confRede[j][k].rota);
				}
			}
		}
	return soma;			
}
	
SolutionList * alocaSolutionList(){
		SolutionList * nova;
		
		nova=(SolutionList*)malloc(sizeof(SolutionList));
		if(nova==NULL){
			erro();
			exit(1);
		}
		
		nova->ini=nova->fim=NULL;
		nova->tam=0;
		return nova;
}

void insereSolutionListOrdenado(SolutionList * list, Node * novo){
	SolutionList * aux;
	Node * aux1;
	int i;
	//printf("ENTROU 1\n");
	
	if(list->tam==0){
		list->ini=list->fim=novo;
		list->tam++;
		
		//printf("ENTROU 2\n");
	}
	
	else if((novo->sol.fitness) < (list->ini->sol.fitness)){
		novo->prox=list->ini;
		list->ini->ant=novo;
		list->ini=novo;
		list->tam++;
		
	//printf("ENTROU 3\n");
	}
	
	else if((novo->sol.fitness) >= (list->fim->sol.fitness)){
		novo->ant=list->fim;
		list->fim->prox=novo;
		list->fim=novo;
		list->tam++;
		
	//printf("ENTROU 4\n");
	}
	
	else{
		
		
		for(aux1=list->ini;aux1!=list->fim; aux1=aux1->prox){
			if(aux1->prox->sol.fitness > novo->sol.fitness){
				novo->prox=aux1->prox;
				novo->ant=aux1;
				aux1->prox=novo;
				list->tam++;
				
				
				break;
			}
		}
	}
	
}
			
	
void imprimeSolutionList(SolutionList * list){
	
	FILE *fp;
	fp=fopen("TesteSolutionList.txt", "w");
	int i,j,k;
	Node * aux;
	fprintf(fp, "TAMANHO DA LISTA %d\n", list->tam);
	
	for(aux=list->ini; aux!=NULL; aux=aux->prox){
		for(i=0; i<n; i++)
		{
			for(j=0; j<n; j++)
			{
				if(E[i][j]==1)
				{
					fprintf(fp,"\t\tLINK DIRETO DE I[%d] J[%d]\n", i, j);

					for(k=0; k<NUM_SLOTS; k++)
					{
						fprintf(fp,"%d ", aux->sol.rnet[i][j].slots[k]);
					}
					fprintf(fp,"\n");
					
				}
			}
		}
		fprintf(fp,"\n");	
		fprintf(fp,"ERROS: %d\n", aux->sol.erros);
		fprintf(fp,"\n");	
		for(i=0; i<n; i++)
		{
			for(j=0; j<n; j++)
			{
				fprintf(fp,"%d ", aux->sol.confRede[i][j].rota);
			}	
			fprintf(fp,"\n");	
		}
		fprintf(fp,"\n");	
		fprintf(fp,"Fitness: %d\n", aux->sol.fitness);
	}	

}

void imprimeSolutionList2(SolutionList * list){
	
	FILE *fp;
	fp=fopen("TesteSolutionList2.txt", "w");
	int i,j,k;
	Node * aux;
	fprintf(fp, "TAMANHO DA LISTA %d\n", list->tam);
	
	for(aux=list->ini; aux!=NULL; aux=aux->prox){
		for(i=0; i<n; i++)
		{
			for(j=0; j<n; j++)
			{
				if(E[i][j]==1)
				{
					fprintf(fp,"\t\tLINK DIRETO DE I[%d] J[%d]\n", i, j);

					for(k=0; k<NUM_SLOTS; k++)
					{
						fprintf(fp,"%d ", aux->sol.rnet[i][j].slots[k]);
					}
					fprintf(fp,"\n");
					
				}
			}
		}
		fprintf(fp,"\n");	
		fprintf(fp,"ERROS: %d\n", aux->sol.erros);
		fprintf(fp,"\n");	
		for(i=0; i<n; i++)
		{
			for(j=0; j<n; j++)
			{
				fprintf(fp,"%d ", aux->sol.confRede[i][j].rota);
			}	
			fprintf(fp,"\n");	
		}
		fprintf(fp,"\n");	
		fprintf(fp,"Fitness: %d\n", aux->sol.fitness);
		for(i=0; i<n; i++)
		{
			for(j=0; j<n; j++)
			{
				fprintf(fp,"%d ", aux->sol.confRede[i][j].w);
			}	
			fprintf(fp,"\n");	
		}
		fprintf(fp,"\n");
	}	

}

SolutionList * selecionaReprodutores(SolutionList * list){
	
	SolutionList * reprodutores;
	
	reprodutores = alocaSolutionList();
	
	Node * aux;
	
	int selRep; //vai ser o tam da lista vezes uma taxa escolhida
	double randomic;
	int random,random1;
	selRep=(list->tam)*TX_REPRODUCAO; // numero de reprodutores
	//printf("SEL REP %d\n", selRep);
	int i=0;
	//pegara as selRep melhores solucoes da lista e colocara em reprodutores
	for(aux=list->ini; aux!=NULL && i<selRep; aux=aux->prox){
		if(reprodutores->tam==0){
			Node * novo;
			novo=alocaNode(aux->sol);
			insereSolutionListOrdenado(reprodutores,novo);
			i++;
		}
		
		else{
			if(comparaRede(aux->ant->sol.confRede, aux->sol.confRede, TAMANHO_n)){
				Node * novo;
				novo=alocaNode(aux->sol);
				insereSolutionListOrdenado(reprodutores,novo);
				i++;
			}
		}
	}
	
	

	random=selRep+rand()%(list->tam-selRep);
	
	printf("SELECIONAR REPRODUTOR RANDOM: %d\n", random);
	
	aux=list->ini;
	for(i=0; i<random;i++){
		aux=aux->prox;
	}
	
	Node * novo;
	novo=alocaNode(aux->sol);
	insereSolutionListOrdenado(reprodutores,novo);
	
	
	return reprodutores;

}
int calculaRotaCross(RNET ** rnet, int ** qtdRotas, int i, int j, int *freq, int * contaRotaZero, int valorListaTaxada, Rede ** rotas0, Rede ** rotas1){
	
	int route,achou;
	int teste;
	teste=*freq;
	//printf("FREQ %d ", *freq);
	
	if((*contaRotaZero)	< valorListaTaxada){
		(*contaRotaZero)++;
		route=rotas0[i][j].rota;
		//printf("CONTAROTASOL1: %d \t ListaTaxada: %d ROTA: %d \n", *contaRotaZero, valorListaTaxada, route);
	}
	else{
		//printf("SOL2\n");
		route=rotas1[i][j].rota;
		//printf("SOL2 ROTA:%d\n", route);
	}
	// else{
		// route=rand()%qtdRotas[i][j];
		// printf("Rota Random: %d\n", route);
		
	// }
	achou=calculaRotaUnica(rnet, i,j,freq,route);
	//printf("Achou Rota: %d\n", achou);
	// if(achou==9999){
		//printf("achou entrou aqui\n");
		// achou=calculaRota(rede, rnet, i,j,&teste);
		// *freq=teste;
		// printf("ACHOU Rota2: %d\n", achou);
	// }
	
	return achou;
}

void removeNode(SolutionList * list){
	Node * aux;
	if(list->tam>0){
		aux=list->fim;
		list->fim=list->fim->ant;
		list->fim->prox=NULL;
		list->tam--;
	}
}

Solucao alocaSolucaoCruzada(Lista *list, int ** qtdRotas, Rede ** rotas0, Rede ** rotas1){
	//list= configuracao de rede inicial, com as demandas da rede
	
	RNET ** rnet; //rnet da solucao que esta sendo criada
	Solucao nova; //solucao que irei retornar para colocar na lista...
	Rede ** rede;
	float taxaFitness;
	int i,j; //manipuladores de loop
	No * aux; // no para percorrer a lista de demandas
	int rota,l,k, cont,freq; // variaveis para fazer alocacao
	int saltos,erros; // numero de erros da alocacao
	int contaRotaZero; //contador para percorrer as rotas da primeira solucao ate comecar a segunda
	int listaTaxada; //ate onde percorre a lista alocando a solucao0
	
	
	rnet=alocaMatrizRNET();
	//aloca o vetorSlotsZERADOS
	alocaVetorSlots(rnet);
	rede=alocaRede();
	nova=alocaSolucaoUnica();
	
	erros=0; //numero de erros naquela solucao
	contaRotaZero=0; //contador para percorrer ate onde ele vai na sol0
	taxaFitness=TAXA_CROSSOVER;
	listaTaxada=list->tam*taxaFitness;
	
	
	for(aux=list->ini; aux!=NULL; aux=aux->prox){
			freq=9999;
			//if(i!=j && rede[i][j].demanda >0)//quer dizer que eh uma ligacao direta dos nodos
			{	
				//printf("\t\t\tDEMANDA DE %d para %d-------------------\n", aux->s,aux->d);
				rota=calculaRotaCross(rnet, qtdRotas,aux->s, aux->d, &freq, &contaRotaZero, listaTaxada,rotas0,rotas1);
				if(rota==9999){
					printf("Nao achou rota nenhuma!\n");
					erros++;
					continue;
				}
				saltos=contaSaltos(aux->s,aux->d,rota); //o numero de saltos existentes naquela demanda 
				//printf("Frequencia utilizada: %d // Rota: %d\n", freq, rota);
				
				if(rota!=9999) //quer dizer que existe uma rota que pode ser alocada
				{
					//printf("Rota: %d\n", rota);
					rede[aux->s][aux->d].w=freq;
					rede[aux->s][aux->d].rota=rota;
					rede[aux->s][aux->d].demanda=traf[aux->s][aux->d];
					
					for(k=0; k<saltos; k++) 
					{	
						cont=0;
						if(M[aux->s][aux->d][rota][k+1]==-1 || freq==9999) break;
						if(E[M[aux->s][aux->d][rota][k]][M[aux->s][aux->d][rota][k+1]] == 0){
							printf("\n\n\tO mostra rota achou uma não existente em %d %d\n\n", aux->s, aux->d);
							break;
						}
						//printf("NODO SAIDA %d\tNODO DESTINO %d\n", M[aux->s][aux->d][rota][k], M[aux->s][aux->d][rota][k+1]);
						//printf("freq: %d\n", rede[aux->s][aux->d].w);
						//printf("Rota: %d\n", rede[i][j].rota);
						//printf("DEMANDA: %d\n", rede[aux->s][aux->d].demanda);
						
						for(l=freq; l< (freq+traf[aux->s][aux->d]); l++)
						{
							if(cont==traf[aux->s][aux->d]) break;
							//atribui 1 nos slots
							rnet[M[aux->s][aux->d][rota][k]][M[aux->s][aux->d][rota][k+1]].slots[l]=1;
							cont++;
							
						}
						if(rnet[M[aux->s][aux->d][rota][k]][M[aux->s][aux->d][rota][k+1]].slots[freq-1]==0)
						{
							//atribui banda de guarda no inicio
							rnet[M[aux->s][aux->d][rota][k]][M[aux->s][aux->d][rota][k+1]].slots[freq-1]=-1;
						}
						if(l<NUM_SLOTS)
						{
							//atribui banda de guarda no final
							rnet[M[aux->s][aux->d][rota][k]][M[aux->s][aux->d][rota][k+1]].slots[l]=-1;
						}
						
					}
					
				}
			}	
		}
		
		nova.erros=erros;
		nova.confRede=rede;
		nova.rnet=rnet;
		nova.fitness=calculaFitness(nova);
		return nova;
}

/*
Solucao alocaSolucaoCruzada(Lista *list, int ** qtdRotas, Solucao sol0, Solucao sol1){
	//list= configuracao de rede inicial, com as demandas da rede
	
	RNET ** rnet; //rnet da solucao que esta sendo criada
	Solucao nova; //solucao que irei retornar para colocar na lista...
	
	float taxaFitness;
	int i,j; //manipuladores de loop
	No * aux; // no para percorrer a lista de demandas
	int rota,l,k, cont,freq; // variaveis para fazer alocacao
	int saltos,erros; // numero de erros da alocacao
	int contaRotaZero; //contador para percorrer as rotas da primeira solucao ate comecar a segunda
	int listaTaxada; //ate onde percorre a lista alocando a solucao0
	int ** matrizRotas; //sao as rotas da solucao que esta sendo calculada
	
	
	rnet=alocaMatrizRNET();
	//aloca o vetorSlotsZERADOS
	alocaVetorSlots(rnet);
	
	nova=alocaSolucaoUnica();
	
	erros=0; //numero de erros naquela solucao
	contaRotaZero=0; //contador para percorrer ate onde ele vai na sol0
	taxaFitness=TAXA_CROSSOVER;
	listaTaxada=list->tam*taxaFitness;
	
	matrizRotas=alocaMatriz();
	zeraMatriz(matrizRotas,n,n);
	
	for(aux=list->ini; aux!=NULL; aux=aux->prox){
			freq=9999;
			//if(i!=j && rede[i][j].demanda >0)//quer dizer que eh uma ligacao direta dos nodos
			{	
				//printf("\t\t\tDEMANDA DE %d para %d-------------------\n", aux->s,aux->d);
				rota=calculaRotaCross(rede[aux->s][aux->d], rnet, qtdRotas,aux->s, aux->d, &freq, &contaRotaZero, listaTaxada,sol0.rotas,sol1.rotas);
				if(rota==9999){
					printf("Nao achou rota nenhuma!\n");
					erros++;
					continue;
				}
				saltos=contaSaltos(aux->s,aux->d,rota); //o numero de saltos existentes naquela demanda 
				//printf("Frequencia utilizada: %d // Rota: %d\n", freq, rota);
				
				if(rota!=9999) //quer dizer que existe uma rota que pode ser alocada
				{
					//printf("Rota: %d\n", rota);
					rede[aux->s][aux->d].w=freq;
					rede[aux->s][aux->d].rota=rota;
					matrizRotas[aux->s][aux->d]=rota;
					for(k=0; k<saltos; k++) 
					{	
						cont=0;
						if(M[aux->s][aux->d][rota][k+1]==-1 || freq==9999) break;
						if(E[M[aux->s][aux->d][rota][k]][M[aux->s][aux->d][rota][k+1]] == 0){
							printf("\n\n\tO mostra rota achou uma não existente em %d %d\n\n", aux->s, aux->d);
							break;
						}
						//printf("NODO SAIDA %d\tNODO DESTINO %d\n", M[aux->s][aux->d][rota][k], M[aux->s][aux->d][rota][k+1]);
						//printf("freq: %d\n", rede[aux->s][aux->d].w);
						//printf("Rota: %d\n", rede[i][j].rota);
						//printf("DEMANDA: %d\n", rede[aux->s][aux->d].demanda);
						
						for(l=freq; l< (freq+traf[aux->s][aux->d]); l++)
						{
							if(cont==traf[aux->s][aux->d]) break;
							//atribui 1 nos slots
							rnet[M[aux->s][aux->d][rota][k]][M[aux->s][aux->d][rota][k+1]].slots[l]=1;
							cont++;
							
						}
						if(rnet[M[aux->s][aux->d][rota][k]][M[aux->s][aux->d][rota][k+1]].slots[freq-1]==0)
						{
							//atribui banda de guarda no inicio
							rnet[M[aux->s][aux->d][rota][k]][M[aux->s][aux->d][rota][k+1]].slots[freq-1]=-1;
						}
						if(l<NUM_SLOTS)
						{
							//atribui banda de guarda no final
							rnet[M[aux->s][aux->d][rota][k]][M[aux->s][aux->d][rota][k+1]].slots[l]=-1;
						}
						
					}
					
				}
			}	
		}
		
		nova.erros=erros;
		//printf("\nERROS %d\n\n", nova.erros);
		nova.rotas=matrizRotas;
		nova.rnet=rnet;
		nova.fitness=calculaFitness(nova);
		return nova;
}

*/

SolutionList * crossOver(SolutionList * listRep, Lista *list, int ** qtdRotas){

	SolutionList * nova;
	nova=alocaSolutionList();
	int i =0;
	int j =0;
	Node * aux;
	Node * aux1;
	int compara;
	for(aux=listRep->ini; aux!=NULL; aux=aux->prox){
		for(aux1=listRep->ini; aux1!=NULL; aux1=aux1->prox){
			compara=comparaRede(aux->sol.confRede, aux1->sol.confRede, TAMANHO_n);
			if(compara){
				Solucao recebe;
				j++;
				recebe=alocaSolucaoCruzada(list,qtdRotas,aux->sol.confRede,aux1->sol.confRede);
				if(recebe.erros==0){
					//printf("\n\n\n\nSolucao %d Fitness %d\n\n\n", i,recebe.fitness);
					Node * novo;
					novo=alocaNode(recebe);
					insereSolutionListOrdenado(nova,novo);
					i++;
				}
			}
		}
	}
	printf("VALOR DE J/I: %d/%d\n", j,i);
	return nova;
}


SolutionList * melhoresNovaGeracao(SolutionList * novaGeracao){
	SolutionList * melhores;
	
	melhores=alocaSolutionList();
	
	Node * aux;
	
	int conta = 10; //era NUM_SOLUCOES
	int i = 0;
	
	for(aux=novaGeracao->ini ; aux!=NULL ; aux=aux->prox ){
		if(melhores->tam==0){
			Node * novo;
			novo=alocaNode(aux->sol);
			
			insereSolutionListOrdenado(melhores, novo);
			i++;
			if(i==conta) break;
		}
		
		else{
			if(comparaRede(aux->ant->sol.confRede,aux->sol.confRede, TAMANHO_n)){
				Node * novo;
				novo=alocaNode(aux->sol);
				
				insereSolutionListOrdenado(melhores, novo);
				i++;
				if(i==conta) break;
			}
		}
	}
	
	return melhores;
}

void mutacaoSolutionList(Lista * list, int ** qtdRotas, SolutionList * lista){
	//(list,rede,qtdRotas,...,)
	Node * aux;
	Solucao nova;
	Rede ** mutar;
	int i;
	//printf("PASSOU12\n");
	int posicao, linha, coluna, novaRota;
	linha = coluna = 0;
	
	posicao = rand()%lista->tam;
	//printf("posicao %d\n",posicao);
	
	aux=lista->ini;
	for(i =0 ; i < posicao; i++){
		aux = aux->prox;
	}
	//printf("PASSOU1\n");
	
	mutar=aux->sol.confRede;
	roleta(&linha, &coluna);

	
	novaRota=rand()%qtdRotas[linha][coluna];
	printf("LINHA %d COLUNA %d ROTA %d\n", linha, coluna, novaRota);
	mutar[linha][coluna].rota=novaRota;
	//printf("PASSOU1\n");
	//verificar se isso funciona.
	nova=alocaSolucaoCruzada(list,qtdRotas,mutar,mutar);
	if(nova.erros==0){
		printf("entrou\n");
		aux=alocaNode(nova);
	}
	
	
}

SolutionList * substituiPopulacao(SolutionList * velhaG, SolutionList * novaG){
	
	SolutionList * nova;
	Node * aux;
	int i;
	
	nova=alocaSolutionList();
	//velha + nova
	for(aux=novaG->ini; aux!=NULL; aux=aux->prox){
		Node * novo;
		novo=alocaNode(aux->sol);
		insereSolutionListOrdenado(velhaG, novo);
		//printf("OI\n");
	}
	
	// velhaG->fim->prox=novaG->ini;
	// novaG->ini->ant=velhaG->fim;
	
	aux=velhaG->ini;
	
	for(i=0; i<NUM_SOLUCOES && aux!=NULL; i++){
		insereSolutionListOrdenado(nova, aux);
		aux=aux->prox;
	}
		
	return nova;
}
